const { app, BrowserWindow, ipcMain, shell } = require('electron');
const path = require('path');
const { spawn, exec } = require('child_process');
const fs = require('fs');
const kill = require('tree-kill'); // 添加 tree-kill

let mainWindow;
let productionWindows = []; // 存储生产线窗口
let backendProcess;
let isQuitting = false;

function createMainWindow() {
  mainWindow = new BrowserWindow({
    width: 1920,
    height: 1080,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false,
      webSecurity: false // 允许跨域请求
    },
    icon: path.join(__dirname, 'icons/favicon.ico'),
    title: 'Wabtec Console Launcher',
    autoHideMenuBar: true, // 自动隐藏菜单栏
    menuBarVisible: false  // 不显示菜单栏
  });

  // 启动后端服务
  startServices();

  // 等待服务启动后加载launcher界面
  const loadMainPage = () => {
    if (app.isPackaged) {
      mainWindow.loadFile(path.join(__dirname, 'frontend/dist/index.html'));
    } else {
      // 开发环境：重试加载直到成功
      const tryLoad = () => {
        mainWindow.loadURL('http://localhost:5173')
          .catch(() => {
            console.log('等待Vite服务器启动...');
            setTimeout(tryLoad, 1000);
          });
      };
      tryLoad();
    }
  };

  // 立即尝试加载
  loadMainPage();

  // 拦截新窗口打开请求
  mainWindow.webContents.setWindowOpenHandler(({ url, frameName, features }) => {
    // 解析窗口特性
    const windowFeatures = parseWindowFeatures(features);
    
    // 创建新的生产线窗口
    const productionWindow = new BrowserWindow({
      width: windowFeatures.width || 1920,
      height: windowFeatures.height || 1080,
      webPreferences: {
        nodeIntegration: true,
        contextIsolation: false,
        webSecurity: false
      },
      icon: path.join(__dirname, 'icons/favicon.ico'), // 生产线窗口也使用相同图标
      autoHideMenuBar: true, // 自动隐藏菜单栏
      menuBarVisible: false, // 不显示菜单栏
      fullscreen: windowFeatures.fullscreen || false,
      title: `Wabtec Production Lines - ${frameName}`
    });

    // 加载对应的URL
    if (app.isPackaged) {
      // 生产环境：需要处理hash路由
      const hashPath = url.split('#')[1] || '/';
      productionWindow.loadFile(path.join(__dirname, 'frontend/dist/index.html'), {
        hash: hashPath
      });
    } else {
      productionWindow.loadURL(url);
    }

    // 将窗口添加到管理数组
    productionWindows.push(productionWindow);

    // 窗口关闭时从数组中移除，并检查是否需要退出应用
    productionWindow.on('closed', () => {
      const index = productionWindows.indexOf(productionWindow);
      if (index > -1) {
        productionWindows.splice(index, 1);
      }
      
      // 如果所有生产线窗口都关闭了，且主窗口也被隐藏，则退出应用
      if (productionWindows.length === 0 && mainWindow && !mainWindow.isVisible()) {
        app.quit();
      }
    });

    return { action: 'deny' }; // 阻止默认的window.open行为
  });

  // 主窗口关闭处理
  mainWindow.on('close', (event) => {
    if (!isQuitting) {
      event.preventDefault();
      
      // 检查是否有生产线窗口打开
      if (productionWindows.length > 0) {
        // 如果有生产线窗口，只隐藏主窗口
        mainWindow.hide();
        console.log('主窗口已隐藏，生产线窗口继续运行');
      } else {
        // 如果没有生产线窗口，则真正退出应用
        console.log('没有生产线窗口，开始退出应用...');
        isQuitting = true;
        
        // 停止后端服务
        stopServices();
        
        // 给一些时间让服务停止，然后真正关闭窗口
        setTimeout(() => {
          if (mainWindow && !mainWindow.isDestroyed()) {
            mainWindow.destroy();
          }
          app.quit();
        }, 2000);
      }
    }
  });

  mainWindow.on('closed', () => {
    mainWindow = null;
    // 确保应用退出
    if (!isQuitting) {
      isQuitting = true;
      stopServices();
      app.quit();
    }
  });
}

// 解析window.open的features字符串
function parseWindowFeatures(features) {
  const result = {};
  if (!features) return result;
  
  features.split(',').forEach(feature => {
    const [key, value] = feature.split('=');
    if (key && value) {
      const trimmedKey = key.trim();
      const trimmedValue = value.trim();
      
      if (trimmedKey === 'width' || trimmedKey === 'height') {
        result[trimmedKey] = parseInt(trimmedValue);
      } else if (trimmedKey === 'fullscreen') {
        result[trimmedKey] = trimmedValue === 'yes';
      }
    }
  });
  
  return result;
}

function startServices() {
  if (app.isPackaged) {
    startPythonBackend();
  } else {
    // 开发环境：只启动Python后端，不启动前端，因为Electron会直接连接Vite
    const backendPath = path.join(__dirname, 'backend');
    backendProcess = spawn('conda', ['run', '-n', 'wabtec_backend', 'uvicorn', 'main:app', '--port', '8001'], {
      cwd: backendPath,
      shell: true,
      detached: false
    });

    backendProcess.stdout.on('data', (data) => {
      console.log(`Backend stdout: ${data}`);
    });

    backendProcess.stderr.on('data', (data) => {
      console.error(`Backend stderr: ${data}`);
    });
  }
}

function startPythonBackend() {
  const backendPath = app.isPackaged 
    ? path.join(process.resourcesPath, 'backend')
    : path.join(__dirname, 'backend');
  
  backendProcess = spawn('conda', ['run', '-n', 'wabtec_backend', 'uvicorn', 'main:app', '--port', '8001'], {
    cwd: backendPath,
    shell: true,
    detached: false // 确保子进程不会脱离父进程
  });

  backendProcess.stdout.on('data', (data) => {
    console.log(`Backend stdout: ${data}`);
  });

  backendProcess.stderr.on('data', (data) => {
    console.error(`Backend stderr: ${data}`);
  });
  
  backendProcess.on('exit', (code, signal) => {
    console.log(`后端进程退出，代码: ${code}, 信号: ${signal}`);
    backendProcess = null;
  });
  
  backendProcess.on('error', (error) => {
    console.error('后端进程启动失败:', error);
    backendProcess = null;
  });
}

function stopServices() {
  console.log('正在停止后端服务...');
  
  if (backendProcess && backendProcess.pid) {
    try {
      // 使用 tree-kill 终止进程树
      kill(backendProcess.pid, 'SIGTERM', (err) => {
        if (err) {
          console.log('优雅关闭失败，尝试强制终止');
          // 如果优雅关闭失败，强制终止
          kill(backendProcess.pid, 'SIGKILL', (err) => {
            if (err) {
              console.error('强制终止失败:', err);
            } else {
              console.log('后端进程已强制终止');
            }
          });
        } else {
          console.log('后端进程已优雅关闭');
        }
      });
    } catch (error) {
      console.error('停止后端服务时出错:', error);
    }
    
    backendProcess = null;
  }
}

app.whenReady().then(createMainWindow);

app.on('window-all-closed', () => {
  isQuitting = true;
  stopServices();
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('activate', () => {
  if (BrowserWindow.getAllWindows().length === 0) {
    createMainWindow();
  } else if (mainWindow && !mainWindow.isVisible()) {
    mainWindow.show();
  }
});

app.on('before-quit', (event) => {
  if (!isQuitting) {
    event.preventDefault();
    isQuitting = true;
    
    console.log('应用正在退出，停止所有服务...');
    stopServices();
    
    // 给进程一些时间来清理，然后强制退出
    setTimeout(() => {
      console.log('强制退出应用');
      app.exit(0);
    }, 3000);
  }
});

// 移除定时检查，避免重复触发退出逻辑
// setInterval(() => {
//   const allWindows = BrowserWindow.getAllWindows();
//   const visibleWindows = allWindows.filter(window => window.isVisible());
//   
//   if (visibleWindows.length === 0 && !isQuitting) {
//     console.log('所有窗口都已关闭，退出应用');
//     app.quit();
//   }
// }, 5000); // 每5秒检查一次